/**
 * 文本处理工具类
 * 提供各种文本处理、格式转换、分析和生成功能
 */
class TextUtils {
  /**
   * 转换为大写
   * @param {string} text - 输入文本
   * @returns {string} 大写文本
   */
  static toUpperCase(text) {
    return text.toUpperCase();
  }
  
  /**
   * 转换为小写
   * @param {string} text - 输入文本
   * @returns {string} 小写文本
   */
  static toLowerCase(text) {
    return text.toLowerCase();
  }
  
  /**
   * 首字母大写
   * @param {string} text - 输入文本
   * @returns {string} 首字母大写的文本
   */
  static capitalize(text) {
    return text.replace(/\b\w/g, char => char.toUpperCase());
  }
  
  /**
   * 去除首尾空格和多余空格
   * @param {string} text - 输入文本
   * @returns {string} 处理后的文本
   */
  static trim(text) {
    return text.trim().replace(/\s+/g, ' ');
  }
  
  /**
   * 反转文本
   * @param {string} text - 输入文本
   * @returns {string} 反转后的文本
   */
  static reverse(text) {
    return text.split('').reverse().join('');
  }
  
  /**
   * 去除空行
   * @param {string} text - 输入文本
   * @returns {string} 去除空行后的文本
   */
  static removeEmptyLines(text) {
    return text.split('\n').filter(line => line.trim() !== '').join('\n');
  }
  
  /**
   * 转换为驼峰命名
   * @param {string} text - 输入文本
   * @returns {string} 驼峰命名文本
   */
  static toCamelCase(text) {
    return text
      .toLowerCase()
      .replace(/[^a-zA-Z0-9]+(.)/g, (match, char) => char.toUpperCase());
  }
  
  /**
   * 转换为下划线命名
   * @param {string} text - 输入文本
   * @returns {string} 下划线命名文本
   */
  static toSnakeCase(text) {
    return text
      .replace(/\W+/g, ' ')
      .split(/ |\B(?=[A-Z])/)
      .map(word => word.toLowerCase())
      .join('_');
  }
  
  /**
   * 转换为短横线命名
   * @param {string} text - 输入文本
   * @returns {string} 短横线命名文本
   */
  static toKebabCase(text) {
    return text
      .replace(/\W+/g, ' ')
      .split(/ |\B(?=[A-Z])/)
      .map(word => word.toLowerCase())
      .join('-');
  }
  
  /**
   * 转换为Pascal命名
   * @param {string} text - 输入文本
   * @returns {string} Pascal命名文本
   */
  static toPascalCase(text) {
    return text
      .toLowerCase()
      .replace(/[^a-zA-Z0-9]+(.)/g, (match, char) => char.toUpperCase())
      .replace(/^(.)/, char => char.toUpperCase());
  }
  
  /**
   * 转换为点分命名
   * @param {string} text - 输入文本
   * @returns {string} 点分命名文本
   */
  static toDotCase(text) {
    return text
      .replace(/\W+/g, ' ')
      .split(/ |\B(?=[A-Z])/)
      .map(word => word.toLowerCase())
      .join('.');
  }
  
  /**
   * 转换为路径命名
   * @param {string} text - 输入文本
   * @returns {string} 路径命名文本
   */
  static toPathCase(text) {
    return text
      .replace(/\W+/g, ' ')
      .split(/ |\B(?=[A-Z])/)
      .map(word => word.toLowerCase())
      .join('/');
  }
  
  /**
   * 分析文本
   * @param {string} text - 输入文本
   * @returns {object} 分析结果
   */
  static analyzeText(text) {
    const characters = text.length;
    const charactersNoSpaces = text.replace(/\s/g, '').length;
    const words = text.trim() ? text.trim().split(/\s+/).length : 0;
    const lines = text.split('\n').length;
    const paragraphs = text.trim() ? text.split(/\n\s*\n/).filter(p => p.trim()).length : 0;
    const sentences = text.trim() ? text.split(/[.!?]+/).filter(s => s.trim()).length : 0;
    
    // 估算阅读时间（按每分钟200字计算）
    const readingTime = Math.ceil(words / 200);
    
    return {
      characters,
      charactersNoSpaces,
      words,
      lines,
      paragraphs,
      sentences,
      readingTime
    };
  }
  
  /**
   * 生成Lorem Ipsum文本
   * @param {number} count - 数量
   * @param {string} unit - 单位 (word, sentence, paragraph)
   * @returns {string} 生成的文本
   */
  static generateLorem(count, unit) {
    const words = [
      'lorem', 'ipsum', 'dolor', 'sit', 'amet', 'consectetur', 'adipiscing', 'elit',
      'sed', 'do', 'eiusmod', 'tempor', 'incididunt', 'ut', 'labore', 'et', 'dolore',
      'magna', 'aliqua', 'enim', 'ad', 'minim', 'veniam', 'quis', 'nostrud',
      'exercitation', 'ullamco', 'laboris', 'nisi', 'aliquip', 'ex', 'ea', 'commodo',
      'consequat', 'duis', 'aute', 'irure', 'in', 'reprehenderit', 'voluptate',
      'velit', 'esse', 'cillum', 'fugiat', 'nulla', 'pariatur', 'excepteur', 'sint',
      'occaecat', 'cupidatat', 'non', 'proident', 'sunt', 'culpa', 'qui', 'officia',
      'deserunt', 'mollit', 'anim', 'id', 'est', 'laborum'
    ];
    
    const getRandomWords = (num) => {
      const result = [];
      for (let i = 0; i < num; i++) {
        result.push(words[Math.floor(Math.random() * words.length)]);
      }
      return result;
    };
    
    const generateSentence = () => {
      const wordCount = Math.floor(Math.random() * 10) + 5; // 5-14个单词
      const sentence = getRandomWords(wordCount).join(' ');
      return sentence.charAt(0).toUpperCase() + sentence.slice(1) + '.';
    };
    
    const generateParagraph = () => {
      const sentenceCount = Math.floor(Math.random() * 5) + 3; // 3-7个句子
      const sentences = [];
      for (let i = 0; i < sentenceCount; i++) {
        sentences.push(generateSentence());
      }
      return sentences.join(' ');
    };
    
    switch (unit) {
      case 'word':
        return getRandomWords(count).join(' ');
      case 'sentence':
        const sentences = [];
        for (let i = 0; i < count; i++) {
          sentences.push(generateSentence());
        }
        return sentences.join(' ');
      case 'paragraph':
      default:
        const paragraphs = [];
        for (let i = 0; i < count; i++) {
          paragraphs.push(generateParagraph());
        }
        return paragraphs.join('\n\n');
    }
  }
  
  /**
   * 生成随机文本
   * @param {number} count - 数量
   * @param {string} unit - 单位 (word, sentence, paragraph)
   * @returns {string} 生成的文本
   */
  static generateRandom(count, unit) {
    const chars = 'abcdefghijklmnopqrstuvwxyz';
    
    const getRandomWord = () => {
      const length = Math.floor(Math.random() * 8) + 3; // 3-10个字符
      let word = '';
      for (let i = 0; i < length; i++) {
        word += chars[Math.floor(Math.random() * chars.length)];
      }
      return word;
    };
    
    const generateSentence = () => {
      const wordCount = Math.floor(Math.random() * 10) + 5; // 5-14个单词
      const words = [];
      for (let i = 0; i < wordCount; i++) {
        words.push(getRandomWord());
      }
      const sentence = words.join(' ');
      return sentence.charAt(0).toUpperCase() + sentence.slice(1) + '.';
    };
    
    const generateParagraph = () => {
      const sentenceCount = Math.floor(Math.random() * 5) + 3; // 3-7个句子
      const sentences = [];
      for (let i = 0; i < sentenceCount; i++) {
        sentences.push(generateSentence());
      }
      return sentences.join(' ');
    };
    
    switch (unit) {
      case 'word':
        const words = [];
        for (let i = 0; i < count; i++) {
          words.push(getRandomWord());
        }
        return words.join(' ');
      case 'sentence':
        const sentences = [];
        for (let i = 0; i < count; i++) {
          sentences.push(generateSentence());
        }
        return sentences.join(' ');
      case 'paragraph':
      default:
        const paragraphs = [];
        for (let i = 0; i < count; i++) {
          paragraphs.push(generateParagraph());
        }
        return paragraphs.join('\n\n');
    }
  }
  
  /**
   * 重复文本
   * @param {string} text - 要重复的文本
   * @param {number} count - 重复次数
   * @returns {string} 重复后的文本
   */
  static repeatText(text, count) {
    const result = [];
    for (let i = 0; i < count; i++) {
      result.push(text);
    }
    return result.join('\n');
  }
  
  /**
   * 统计字符频率
   * @param {string} text - 输入文本
   * @returns {object} 字符频率统计
   */
  static getCharacterFrequency(text) {
    const frequency = {};
    for (const char of text.toLowerCase()) {
      if (/[a-z]/.test(char)) {
        frequency[char] = (frequency[char] || 0) + 1;
      }
    }
    return frequency;
  }
  
  /**
   * 统计单词频率
   * @param {string} text - 输入文本
   * @returns {object} 单词频率统计
   */
  static getWordFrequency(text) {
    const words = text.toLowerCase().match(/\b\w+\b/g) || [];
    const frequency = {};
    for (const word of words) {
      frequency[word] = (frequency[word] || 0) + 1;
    }
    return frequency;
  }
  
  /**
   * 提取邮箱地址
   * @param {string} text - 输入文本
   * @returns {Array} 邮箱地址数组
   */
  static extractEmails(text) {
    const emailRegex = /\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b/g;
    return text.match(emailRegex) || [];
  }
  
  /**
   * 提取URL
   * @param {string} text - 输入文本
   * @returns {Array} URL数组
   */
  static extractUrls(text) {
    const urlRegex = /https?:\/\/(www\.)?[-a-zA-Z0-9@:%._\+~#=]{1,256}\.[a-zA-Z0-9()]{1,6}\b([-a-zA-Z0-9()@:%_\+.~#?&//=]*)/g;
    return text.match(urlRegex) || [];
  }
  
  /**
   * 提取电话号码
   * @param {string} text - 输入文本
   * @returns {Array} 电话号码数组
   */
  static extractPhones(text) {
    const phoneRegex = /(?:\+?86)?\s*1[3-9]\d{9}|(?:\d{3,4}-)?\d{7,8}/g;
    return text.match(phoneRegex) || [];
  }
  
  /**
   * 计算文本相似度（简单的Jaccard相似度）
   * @param {string} text1 - 第一个文本
   * @param {string} text2 - 第二个文本
   * @returns {number} 相似度 (0-1)
   */
  static calculateSimilarity(text1, text2) {
    const words1 = new Set(text1.toLowerCase().match(/\b\w+\b/g) || []);
    const words2 = new Set(text2.toLowerCase().match(/\b\w+\b/g) || []);
    
    const intersection = new Set([...words1].filter(word => words2.has(word)));
    const union = new Set([...words1, ...words2]);
    
    return union.size === 0 ? 0 : intersection.size / union.size;
  }
  
  /**
   * 格式化JSON
   * @param {string} jsonString - JSON字符串
   * @param {number} indent - 缩进空格数
   * @returns {string} 格式化后的JSON
   */
  static formatJson(jsonString, indent = 2) {
    try {
      const parsed = JSON.parse(jsonString);
      return JSON.stringify(parsed, null, indent);
    } catch (error) {
      throw new Error('无效的JSON格式');
    }
  }
  
  /**
   * 压缩JSON
   * @param {string} jsonString - JSON字符串
   * @returns {string} 压缩后的JSON
   */
  static minifyJson(jsonString) {
    try {
      const parsed = JSON.parse(jsonString);
      return JSON.stringify(parsed);
    } catch (error) {
      throw new Error('无效的JSON格式');
    }
  }
  
  /**
   * 转义HTML
   * @param {string} text - 输入文本
   * @returns {string} 转义后的文本
   */
  static escapeHtml(text) {
    const map = {
      '&': '&amp;',
      '<': '&lt;',
      '>': '&gt;',
      '"': '&quot;',
      "'": '&#39;'
    };
    return text.replace(/[&<>"']/g, char => map[char]);
  }
  
  /**
   * 反转义HTML
   * @param {string} text - 输入文本
   * @returns {string} 反转义后的文本
   */
  static unescapeHtml(text) {
    const map = {
      '&amp;': '&',
      '&lt;': '<',
      '&gt;': '>',
      '&quot;': '"',
      '&#39;': "'"
    };
    return text.replace(/&(amp|lt|gt|quot|#39);/g, entity => map[entity]);
  }
}

module.exports = {
  TextUtils
};